﻿/*
Nombre:                         BancoDao
Descripcion:                    Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.BancoDao
Dependencias:                 
Fecha de creación:              20080509
Autor:                          VMORALES
Fecha de modifcación:           20090328
Responsable:                    VMORALES
Num. de modifcación:            1
*/

#region Imports

using NUnit.Framework;
using Electrocucaracha.AdminPersonal.DAO.Entidades;
using Spring.Context.Support;
using Spring.Context;
using System.IO;
using System;
using System.Configuration;
using System.Collections.Generic;
using System.Linq.Expressions;
using log4net.Config;

#endregion

namespace Electrocucaracha.AdminPersonal.DAO.Test
{
    [TestFixture(Description="Casos de prueba realizados para la clase Electrocucaracha.AdminPersonal.DAO.BancoDao")]
    public class BancoDao : GenericoDao<BancoDao, BancoDTO>
    {
        #region Constantes

        public const int CANTIDAD_ENTIDADES_PRUEBA = 5;

        #endregion

        #region Miembros

        public readonly static string Instancia = "BancoDao";
        private IBancoDao dao;
        private DateTime inicio;
        private DateTime inicioAplicacion;
        private int id = -1;
        private string descripcionUtilizada = "Prueba-" + DateTime.Today.ToShortDateString();
        private int bancosCreados;

        #endregion

        #region Propiedades

        #endregion

        #region Constructores

        #endregion

        #region Funciones

        /// <summary>
        /// Funcion que formatea el banco para que sea mostrado en el log
        /// </summary>
        /// <param name="banco">Instancia a ser formateada</param>
        /// <returns>Id, estatus y descripcion</returns>
        public override string Formatear(BancoDTO banco)
        {
            return String.Format("id :\t{0}\t{1}\tDescripcion : {2}", 
                banco.Id,
                (banco.Activo ? "Activo\t" : "Inactivo"),
                banco.Descripcion);
        }//Formatear

        /// <summary>
        /// Funcion que obtiene un objeto dao que comparten todas las pruebas
        /// </summary>
        [TestFixtureSetUp]
        public void Inicializar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Inicializar()");

            inicioAplicacion = DateTime.Now;

            ImprimirDebug("Inicio del caso de prueba : " + inicioAplicacion.ToShortDateString());

            IApplicationContext ctx = new XmlApplicationContext("file://DAO.xml");
            ImprimirDebug(BancoDao.Instancia + ".Inicializar()");
            dao = (IBancoDao)ctx.GetObject(BancoDao.Instancia);
            Assert.IsNotNull(dao, "No se pudo obtener una instancia dao para el catalogo de bancos");

            AgregarDatos();

            ImprimirInfo("Fin Test.BancoDao.Inicializar()");
        }//Inicializar

        /// <summary>
        /// Funcion que agrega a la base de datos un conjunto de datos para realizar las pruebas
        /// </summary>
        private void AgregarDatos()
        {
            ImprimirInfo("Inicio Test.BancoDao.AgregarDatos()");

            BancoDTO tmp = null;
            BancoDTO[] bancos = null;

            ImprimirDebug("Agregando bancos a la base de datos");
            for (int i = 0; i < CANTIDAD_ENTIDADES_PRUEBA; i++)
            {
                tmp = new BancoDTO() { Descripcion = descripcionUtilizada + "[" + i + "]", Activo = true };
                Assert.IsTrue(dao.Agregar(ref tmp), "No se pudo agregar el banco numero : " +  i);
            }

            //Desactivo la mitad de los bancos agregados
            bancos = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(bancos, "No se pudieron obtener los bancos de prueba agregados");
            bancosCreados = bancos.Length;
            Assert.AreEqual(CANTIDAD_ENTIDADES_PRUEBA, bancosCreados, "No se crearon la cantidad de bancos solicitada");
            if (bancos.Length > 1)
            {
                id = bancos[0].Id;
                ImprimirDebug("Id. a ser utilizado en las pruebas : " + id);
            }

            ImprimirDebug("Desactivando algunos bancos de la base de datos");
            for (int i = 0; i < bancos.Length; i+=2)
            {
                Assert.IsTrue(dao.Desactivar(bancos[i]), "No se pudo desactivar el banco con id : " + bancos[i]);
            }

            ImprimirInfo("Fin Test.BancoDao.AgregarDatos()");
        }//AgregarDatos

        /// <summary>
        /// Funcion que libera recursos y restablece los valores en la tabla
        /// </summary>
        [TestFixtureTearDown]
        public void Finalizar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Finalizar()");

            EliminarDatos();

            ImprimirDebug("Duracion total : " + (DateTime.Now - inicioAplicacion).TotalSeconds + " seg.");

            ImprimirInfo("Fin Test.BancoDao.Finalizar()");
        }//Finalizar

        /// <summary>
        /// Funcion que elimina de la base de datos el conjunto de datos agregados para realizar pruebas
        /// </summary>
        private void EliminarDatos()
        {
            ImprimirInfo("Inicio Test.BancoDao.EliminarDatos()");

            //Desactivo la mitad de los bancos agregados
            BancoDTO[] bancos = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(bancos, "No obtuvo ningun banco con la descripcion utilizada");
            Assert.AreEqual(bancos.Length, CANTIDAD_ENTIDADES_PRUEBA, "Se obtuvieron mas bancos con la misma descripcion");
            ImprimirDebug("Eliminando bancos de la base de datos");
            Assert.AreEqual(dao.Eliminar(bancos), bancos.Length , "No se pudo eliminar todos los bancos de prueba");

            ImprimirDebug("Reseteando el identificador de la tabla");
            dao.ResetearId();

            ImprimirInfo("Fin Test.BancoDao.EliminarDatos()");
        }//EliminarDatos

        /// <summary>
        /// Funcion que imprime en la bitacora datos utilices acerca de la tabla de bancos
        /// </summary>
        [SetUp]
        public void ImprimirEstatusAntes()
        {
            ImprimirInfo("Inicio Test.BancoDao.ImprimirEstatusAntes()");

            int cant = dao.ObtenerCantidad();

            ImprimirDebug("ImprimirEstatusAntes()");
            ImprimirDebug("Cantidad de bancos existentes antes de la prueba: " + cant);
            if (cant > 0)
            {
                ImprimirDebug("Bancos existentes: ", dao.Obtener());
            }

            ImprimirDebug("-------------------------------------------------------------------------------\n");

            // TODO: Imprimir el ultimo identificador de la tabla
            inicio = DateTime.Now;

            ImprimirInfo("Fin Test.BancoDao.ImprimirEstatusAntes()");
        }//ImprimirEstatusAntes

        /// <summary>
        /// Funcion que elimina los datos temporales del catalogo utilizados para las pruebas
        /// </summary>
        [TearDown]
        public void ImprimirEstatusDespues()
        {
            ImprimirInfo("Inicio Test.BancoDao.ImprimirEstatusDespues()");

            ImprimirDebug("-------------------------------------------------------------------------------\n");

            int cant = dao.ObtenerCantidad();

            ImprimirDebug("ImprimirEstatusDespues()");
            ImprimirDebug("Cantidad de bancos existentes despues de la prueba: " + cant);
            if (cant > 0)
            {
                ImprimirDebug("Bancos existentes: ", dao.Obtener());
            }

            // TODO: Imprimir el ultimo identificador de la tabla
            ImprimirDebug("Duracion : " + (DateTime.Now - inicio).TotalSeconds + " seg.");

            ImprimirInfo("Fin Test.BancoDao.ImprimirEstatusDespues()");
        }//ImprimirEstatusDespues

        #endregion

        #region IGenericoDao

        /// <summary>
        /// Valida que se pueda agregar bancos a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar bancos a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Agregar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Agregar()");

            const string descripcionAgregar = "Agregar";

            ImprimirDebug("Obteniendo la cantidad de bancos inicial");
            int cantidadAntes = dao.ObtenerCantidad();
            ImprimirDebug("Cantidad de bancos existentes : " + cantidadAntes);
            BancoDTO bancoPrueba = new BancoDTO()
            {
                Descripcion = descripcionAgregar,
                Activo = true
            };

            Assert.IsNotNull(bancoPrueba, "No se pudo inicializar los campos para el objeto a ser agregado");
            ImprimirDebug("Banco a ser agregado : ", bancoPrueba);
            Assert.IsTrue(dao.Agregar(ref bancoPrueba), "Ha ocurrido algun error al intentar agregar un banco");
            ImprimirDebug("Banco agregado: ", bancoPrueba);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de bancos despues de la accion de agregar");

            //Validando los datos contra la base de datos
            ImprimirDebug("Validando los datos contra la base de datos");
            BancoDTO bancoBD = dao.Obtener(bancoPrueba.Id);
            Assert.IsNotNull(bancoBD, "No se pudo obtener el banco agregado en la base de datos");
            ImprimirDebug("Banco obtenido desde la base de datos : " , bancoBD);
            Assert.AreEqual(bancoBD.Descripcion, descripcionAgregar, "No coinciden la descripcion del banco agregado");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInvalido = new BancoDTO() { Id = -1 };
            ImprimirDebug("Banco invalido a agregar : ", bancoInvalido);
            Assert.Throws<DAOException>(() => dao.Agregar(ref bancoInvalido));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Eliminar(bancoBD), "No se pudo eliminar el banco que fue agregado en la prueba");

            ImprimirInfo("Fin Test.BancoDao.Agregar()");
        }//Agregar

        /// <summary>
        /// Valida que se pueda agregar varios bancos a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda agregar varios bancos a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void AgregarVarios()
        {
            ImprimirInfo("Inicio Test.BancoDao.AgregarVarios()");

            int cantidadAntes = dao.ObtenerCantidad();
            const int cantidadBancosAgregar = 5;
            const string descripcionAgregar = "Agregar";

            ImprimirDebug("Cantidad de bancos a agregar: " + cantidadBancosAgregar);
            BancoDTO[] bancosPrueba = new BancoDTO[cantidadBancosAgregar];
            for (int i = 0; i < bancosPrueba.Length; i++)
            {
                bancosPrueba[i] = new BancoDTO()
                {
                    Descripcion = descripcionAgregar + i,
                    Activo = (1 % 2 == 1)
                };
            }

            Assert.IsNotEmpty(bancosPrueba, "No se pudo inicializar los bancos a ser agregados");
            ImprimirDebug("Bancos a ser agregados : " , bancosPrueba);
            Assert.AreEqual(dao.Agregar(ref bancosPrueba), bancosPrueba.Length, "Ha ocurrido algun error al intentar agregar los bancos");
            ImprimirDebug("Bancos agregados : ", bancosPrueba);
            Assert.Greater(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de bancos despues de la accion de agregar");

			//Validando los datos contra la base de datos
            ImprimirDebug("Validando los datos contra la base de datos");
            BancoDTO[] bancosBD = dao.ObtenerPorDescripcionSimilar(descripcionAgregar);
            Assert.IsNotNull(bancosBD, "No se obtuvieron los bancos agregados de la base de datos");
            Assert.IsNotEmpty(bancosBD, "El conjunto de bancos obtenidos esta vacio");
            ImprimirDebug("Cantidad de bancos obtenidos desde la base de datos : " + bancosBD.Length);
			Assert.AreEqual(bancosBD.Length, cantidadBancosAgregar, "No coinciden la cantidad de bancos agregados");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO[] bancosInvalidos = new BancoDTO[bancosPrueba.Length];
            for (int i = 0, j = -1; i < bancosInvalidos.Length; i++, j--)
            {
                bancosInvalidos[i] = new BancoDTO();
                bancosInvalidos[i].Id = j;
            }

            ImprimirDebug("Bancos invalidos a agregar : ", bancosInvalidos);
            Assert.Throws<DAOException>(() => dao.Agregar(ref bancosInvalidos));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(dao.Eliminar(bancosPrueba), bancosPrueba.Length, "No se pudo eliminar los bancos que fueron utilizados en la prueba");

            ImprimirInfo("Fin Test.BancoDao.AgregarVarios()");
        }//AgregarVarios

        /// <summary>
        /// Valida que se pueda elimar un banco de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda elimar un banco de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Eliminar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Eliminar()");

            int cantidadAntes = dao.ObtenerCantidad();

            //Obtengo un banco de prueba a ser eliminado
            ImprimirDebug("Obteniendo el banco de prueba...");
            BancoDTO b = dao.Obtener(id);
            Assert.IsNotNull(b, "No se pudo obtener el banco a ser utilizado en la prueba");

            //Elimino el banco de prueba
            ImprimirDebug("Banco a eliminar : ", b);
            ImprimirDebug("Cantidad de bancos existentes : " + cantidadAntes);
            Assert.IsTrue(dao.Eliminar(b), "No se pudo elminar el banco de prueba");
            
            //Comprabacion de datos en la base de datos
            ImprimirDebug("Comprobando datos guardados en la base de datos");
            Assert.Less(dao.ObtenerCantidad(), cantidadAntes, "No se vario la cantidad de bancos registrados en la base de datos");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInvalido = new BancoDTO() { Id = -1 };
            ImprimirDebug("Banco invalido a eliminar : ", bancoInvalido);
            Assert.Throws<DAOException>(() => dao.Eliminar(bancoInvalido));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Agregar(ref b), "No se pudo restablecer los datos de prueba");
            id = b.Id;

            ImprimirInfo("Fin Test.BancoDao.Eliminar()");
        }//Eliminar

        /// <summary>
        /// Valida que se pueda eliminar varios bancos a la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda eliminar varios bancos a la capa de persistencia")]
        [Category("IGenericoDao")]
        public void EliminarVarios()
        {
            ImprimirInfo("Inicio Test.BancoDao.EliminarVarios()");

            //Obtengo un conjunto de bancos de prueba a ser elminadas
            ImprimirDebug("Obteniendo los bancos de prueba...");
            BancoDTO[] bancosPrueba = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(bancosPrueba, "No se pudieron obtener los bancos para la prueba");
            ImprimirDebug("Cantidad de bancos a eliminar : " + bancosPrueba.Length);
            Assert.AreEqual(bancosPrueba.Length, CANTIDAD_ENTIDADES_PRUEBA, "No se obtuvo la misma cantidad de bancos para la prueba");
            
            ImprimirDebug("Bancos a ser eliminados : ", bancosPrueba);
            Assert.AreEqual(bancosPrueba.Length, dao.Eliminar(bancosPrueba), "No se pudieron eliminar todos los bancos de prueba");
            ImprimirDebug("Bancos eliminados exitosamente");

            ImprimirDebug("Validando contra la base de datos");
            foreach (BancoDTO b in bancosPrueba)
            {
                ImprimirDebug("Validando la inexistencia del banco : " , b);
                Assert.IsFalse(dao.Existe(b), "Se encontro el banco con id : " + b.Id);
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO[] bancosInexistentes = new BancoDTO[bancosPrueba.Length];
            for (int i = 0, j = -1; i < bancosInexistentes.Length; i++, j--)
            {
                bancosInexistentes[i] = new BancoDTO();
                bancosInexistentes[i].Id = j;
            }

            ImprimirDebug("Bancos inexistentes a eliminar : ", bancosInexistentes);
            Assert.Throws<DAOException>(() => dao.Eliminar(bancosInexistentes));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(bancosPrueba.Length, dao.Agregar(ref bancosPrueba), "No se pudieron restaurar todos los bancos de prueba");
            for (int i = 0; i < bancosPrueba.Length; i += 2)
            {
                Assert.IsTrue(dao.Desactivar(bancosPrueba[i]), "No se pudo desactivar el banco con id : " + bancosPrueba[i]);
            }
            if (bancosPrueba.Length > 1)
            {
                id = bancosPrueba[0].Id;
            }

            ImprimirInfo("Fin Test.BancoDao.EliminarVarios()");
        }//EliminarVarios

        /// <summary>
        /// Valida que se pueda obtener un banco a partir de su identificador
        /// </summary>
        [Test(Description = "Valida que se pueda obtener un banco a partir de su identificador")]
        [Category("IGenericoDao")]
        public void ObtenerPorId()
        {
            ImprimirInfo("Inicio Test.BancoDao.ObtenerPorId()");

            ImprimirDebug("Obteniendo el banco con el id : " + id);
            BancoDTO bancoPrueba = dao.Obtener(id);

            Assert.IsNotNull(bancoPrueba, "No se pudo obtener el banco con el identificador : " + id);
            ImprimirDebug("Banco obtenido : ", bancoPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.Throws<DAOException>(() => dao.Obtener(-2));

            ImprimirInfo("Fin Test.BancoDao.ObtenerPorId()");
        }//ObtenerPorId

        /// <summary>
        /// Valida que se pueda obtener todos los bancos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener todos los bancos de la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerTodos()
        {
            ImprimirInfo("Inicio Test.BancoDao.ObtenerTodos()");
            
            BancoDTO[] bancosPrueba = dao.Obtener();
            Assert.IsNotNull(bancosPrueba, "Se obtuvo un objeto nulo");
            Assert.IsNotEmpty(bancosPrueba, "No se pudo obtener algun banco de la capa de persistencia");
            ImprimirDebug("Bancos obtenidos : ", bancosPrueba);

            ImprimirDebug("Validando cantidad de bancos obtenidos");
            Assert.AreEqual(bancosPrueba.Length, dao.ObtenerCantidad(), "No se pudo obtener todos los bancos de la capa de persistencia");

            ImprimirInfo("Fin Test.BancoDao.ObtenerTodos()");
        }//ObtenerTodos

        /// <summary>
        /// Valida que se pueda actualizar un banco en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un banco en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void Actualizar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Actualizar()");

            string descripcionNueva = "Actualizar";
            string descripcionOriginal;

            //Obtengo un banco de prueba a ser actualizado
            ImprimirDebug("Obteniendo el banco de prueba...");
            BancoDTO b = dao.Obtener(id);
            Assert.IsNotNull(b, "No se pudo obtener el banco a ser utilizado en la prueba");

            //Actualizo la descripcion del banco agregado
            ImprimirDebug("Banco a actualizar : ", b);
            descripcionOriginal = b.Descripcion;
            b.Descripcion = descripcionNueva;
            Assert.IsTrue(dao.Actualizar(b), "No se pudo actualizar el banco de prueba");
            ImprimirDebug("Banco actualizado : ", b);

            //Comparo que la nueva descripcion se encuentre en la base de datos
            ImprimirDebug("Comprobando datos guardados en la base de datos");
            b = dao.Obtener(b.Id);
            Assert.IsNotNull(b, "No se pudo obtener el banco actualizado desde la base de datos");
            ImprimirDebug("Banco obtenido desde la base de datos: ", b);
            Assert.AreEqual(b.Descripcion, descripcionNueva, "No fue actualizada la descripcion en la base de datos");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInexistente = new BancoDTO() { Id = -1 };
            ImprimirDebug("Banco inexistente a actualizar : ", bancoInexistente);
            Assert.Throws<DAOException>(() => dao.Actualizar(bancoInexistente));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            b.Descripcion = descripcionOriginal;
            Assert.IsTrue(dao.Actualizar(b), "No se pudo restablecer los datos de prueba");

            ImprimirInfo("Fin Test.BancoDao.Actualizar()");
        }//Actualizar

        /// <summary>
        /// Valida que se pueda actualizar un conjunto de bancos en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda actualizar un conjunto de bancos en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ActualizarVarios()
        {
            ImprimirInfo("Inicio Test.BancoDao.ActualizarVarios()");

            string descripcionNueva = "Actualizar";
            IDictionary<int, string> valoresAnteriores = new Dictionary<int, string>();

            //Obtengo un conjunto de bancos de prueba a ser actualizados
            ImprimirDebug("Obteniendo el banco de prueba...");
            BancoDTO[] bancosPrueba = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(bancosPrueba, "No se pudieron obtener los bancos para la prueba");
            ImprimirDebug("Cantidad de bancos a actualizar : " + bancosPrueba.Length);
            Assert.AreEqual(bancosPrueba.Length, CANTIDAD_ENTIDADES_PRUEBA, "No se obtuvo la misma cantidad de bancos para la prueba");
            ImprimirDebug("Bancos a ser actualizados : ", bancosPrueba);

            ImprimirDebug("Actualizando la descripcion de los bancos de prueba");
            foreach (BancoDTO b in bancosPrueba)
            {
                valoresAnteriores.Add(b.Id, b.Descripcion);
                b.Descripcion = descripcionNueva + "[" + b.Id + "]";
            }
            Assert.AreEqual(bancosPrueba.Length, dao.Actualizar(bancosPrueba), "No se pudieron actualizar todos los bancos de prueba");
            ImprimirDebug("Bancos actualizados : " , bancosPrueba);

            ImprimirDebug("Validando contra la base de datos");
            BancoDTO[] bancosPruebaBD = dao.ObtenerPorDescripcionSimilar(descripcionNueva);
            Assert.IsNotNull(bancosPruebaBD, "No se pudieron obtener los bancos actualizados en la base de datos");
            Assert.AreEqual(bancosPruebaBD.Length, bancosPrueba.Length, "No coinciden la cantidad de bancos actualizados en la base de datos");
            bancosPruebaBD = null;

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO[] bancosInexistentes = new BancoDTO[bancosPrueba.Length];
            for (int i = 0, j = -1; i < bancosInexistentes.Length; i++, j--) 
            {
                bancosInexistentes[i] = new BancoDTO();
                bancosInexistentes[i].Id = j;
            }

            ImprimirDebug("Bancos inexistentes a actualizar : ", bancosInexistentes);
            Assert.Throws<DAOException>(() => dao.Actualizar(bancosInexistentes));

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (BancoDTO b in bancosPrueba)
            {
                Assert.IsTrue(valoresAnteriores.ContainsKey(b.Id), "No se guardaron todas las descripciones de los bancos"); 
                b.Descripcion = valoresAnteriores[b.Id];
                Assert.IsTrue(valoresAnteriores.Remove(b.Id), "No se pudo eliminar la descripcion encontrada");
            }
            Assert.AreEqual(valoresAnteriores.Count, 0, "Quedaron descripciones pendientes por restaurar");
            Assert.AreEqual(bancosPrueba.Length, dao.Actualizar(bancosPrueba), "No se pudieron restaurar todos los bancos de prueba");

            ImprimirInfo("Fin Test.BancoDao.ActualizarVarios()");
        }//ActualizarVarios

        /// <summary>
        /// Valida que se pueda validar si existe un banco en particular
        /// </summary>
        [Test(Description = "Valida que se pueda validar si existe un banco en particular")]
        [Category("IGenericoDao")]
        public void Existe()
        {
            ImprimirInfo("Inicio Test.BancoDao.Existe()");

            ImprimirDebug("Obteniendo banco de pruebas con id : " +  id);
            BancoDTO bancoPrueba = dao.Obtener(id);
            Assert.IsNotNull(bancoPrueba, "No se pudo obtener el banco de prueba");
            Assert.IsTrue(bancoPrueba.Descripcion.Contains(descripcionUtilizada), "El banco obtenido no corresponde a los usados para realizar las pruebas");
            ImprimirDebug("Banco obtenido : ", bancoPrueba);

            //Validando informacion
            Assert.IsTrue(dao.Existe(bancoPrueba), "No se pudo encontrar un banco extraido de la capa de persistencia");

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInexistente = new BancoDTO() { Id = -2 };
            ImprimirDebug("Banco inexistente a buscar : " , bancoInexistente);
            Assert.Throws<DAOException>(() => dao.Existe(bancoInexistente));

            ImprimirInfo("Fin Test.BancoDao.Existe()");
        }//Existe

        /// <summary>
        /// Valida que se pueda resetear el identificador autoincremental
        /// </summary>
        [Test(Description = "Valida que se pueda resetear el identificador autoincremental")]
        [Category("IGenericoDao")]
        public void ResetearId()
        {
            ImprimirInfo("Inicio Test.BancoDao.ResetearId()");
            
            BancoDTO[] bancos = dao.Obtener();
            BancoDTO ultimoBanco = null;
            Assert.IsNotNull(bancos, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(bancos, "No se pudieron obtener todos los bancos de la capa de persistencia");

            ultimoBanco = bancos[bancos.Length - 1];
            int ultimoId = ultimoBanco.Id;
            ImprimirDebug("El ultimo banco del catalogo : ", ultimoBanco);
            Assert.Greater(ultimoId, 0, "El ultimo identificador del catalogo de bancos no es mayor a cero");

            //Elimino bancos de prueba
            Assert.IsTrue(dao.Eliminar(ultimoBanco), "Ha ocurrido algun error al intentar el ultimo banco");
            ImprimirDebug("Resetando el valor del identificador");
            dao.ResetearId();

            //Restablezco los datos de prueba utilizados
            Assert.IsTrue(dao.Agregar(ref ultimoBanco), "No se pudo agregar el banco de prueba al catalogo");
            Assert.AreEqual(ultimoId, ultimoBanco.Id, "No se reseteo correctamente el identificador");
            ImprimirDebug("Se ha agregado el banco : ", ultimoBanco);

            ImprimirInfo("Fin Test.BancoDao.ResetearId()");
        }//ResetearId

        /// <summary>
        /// Valida que los datos del objeto sean correctos
        /// </summary>
        [Test(Description = "Valida que los datos del objeto sean correctos")]
        [Category("IGenericoDao")]
        public void Validar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Validar()");
            BancoDTO bancoPrueba;

            //Validacion de objeto nulo
            ImprimirDebug("Validacion de objeto nulo");
            bancoPrueba = null;
            Assert.Throws<DAOException>(() => dao.Validar(bancoPrueba, Validaciones.Nulo));

            //Validacion de descripcion nula
            ImprimirDebug("Validacion de descripcion nula");
            bancoPrueba = new BancoDTO() { Descripcion = null };
            Assert.Throws<DAOException>(() => dao.Validar(bancoPrueba, Validaciones.DescripcionVacia));

            //Validacion de descripcion vacia
            ImprimirDebug("Validacion de descripcion vacia");
            bancoPrueba.Descripcion = string.Empty;
            Assert.Throws<DAOException>(() => dao.Validar(bancoPrueba, Validaciones.DescripcionVacia));

            //Validacion de identificador negativo
            ImprimirDebug("Validacion de identificador negativo");
            bancoPrueba.Descripcion = "Test";
            bancoPrueba.Id = -1;
            Assert.Throws<DAOException>(() => dao.Validar(bancoPrueba, Validaciones.IdentificadorNegativo));
            
            ImprimirInfo("Fin Test.BancoDao.Validar()");
        }//Validar

        /// <summary>
        /// Valida cada uno de los objetos de un conjunto de datos
        /// </summary>
        [Test(Description = "Valida cada uno de los objetos de un conjunto de datos")]
        [Category("IGenericoDao")]
        public void ValidarVarios()
        {
            ImprimirInfo("Inicio Test.BancoDao.ValidarVarios()");

            //Validacion de objeto nulo
            ImprimirDebug("Validacion de objeto nulo");
            BancoDTO[] bancoPrueba = null;
            Assert.Throws<DAOException>(() => dao.Validar(bancoPrueba, Validaciones.Nulo));

            ImprimirInfo("Fin Test.BancoDao.ValidarVarios()");
        }//ValidarVarios

        /// <summary>
        /// Valida que se pueda obtener la cantidad de registros del catalogo de bancos en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda obtener la cantidad de registros del catalogo de bancos en la capa de persistencia")]
        [Category("IGenericoDao")]
        public void ObtenerCantidad()
        {
            ImprimirInfo("Inicio Test.BancoDao.ObtenerCantidad()");
            
            int cantidad = dao.ObtenerCantidad();
			ImprimirDebug("Cantidad obtenida mediante ObtenerCantidad() : " + cantidad);
            BancoDTO[] bancos = dao.Obtener();
			ImprimirDebug("Cantidad obtenida mediante Obtener() : " + bancos.Length);
            Assert.AreEqual(bancos.Length, cantidad, "La cantidad de bancos no coincide");

            ImprimirInfo("Fin Test.BancoDao.ObtenerCantidad()");
        }//ObtenerCantidad

        #endregion

        #region ICatalogo

        /// <summary>
        /// Valida que se puedan obtener los bancos por medio de su descripcion
        /// </summary>
        [Test(Description="Valida que se puedan obtener los bancos por medio de su descripcion")]
        [Category("ICatalogo")]
        public void ObtenerPorDescripcion()
        {
            ImprimirDebug("Inicio Test.BancoDao.ObtenerPorDescripcion()");

            //Obtener banco de prueba existente
            BancoDTO banco = dao.Obtener(id);
            Assert.IsNotNull(banco, "No se pudo obtener un banco de prueba");
            ImprimirDebug("Banco de pruebas obtenido : ", banco);

            ImprimirDebug("Descripcion a buscar : " + banco.Descripcion);
            BancoDTO[] bancos = dao.ObtenerPorDescripcion(banco.Descripcion);
            Assert.IsNotNull(bancos, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(bancos, "No se pudo obtener un conjunto de bancos que compartan la misma descripcion");
            ImprimirDebug("Bancos obtenidos : ", bancos);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.AreEqual(dao.Eliminar(bancos), bancos.Length, "No se pudieron eliminar los bancos de prueba");
            Assert.IsNull(dao.ObtenerPorDescripcion(banco.Descripcion), "Se obtuvo una descripcion eliminada de la base de datos");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(dao.Agregar(ref bancos), bancos.Length, "No se pudo agregar el conjunto de bancos eliminados");
            if (bancos.Length > 0)
            {
                id = bancos[0].Id;
                ImprimirDebug("Nuevo id de pruebas : " + id);
            }

            ImprimirDebug("Fin Test.BancoDao.ObtenerPorDescripcion()");
        }//ObtenerPorDescripcion

        /// <summary>
        /// Valida que se puedan obtener un conjunto de bancos que comparten una descripcion similar
        /// </summary>
        [Test(Description = "Valida que se puedan obtener un conjunto de bancos que comparten una descripcion similar")]
        [Category("ICatalogo")]
        public void ObtenerTodosPorDescripcionSimilar()
        {
            ImprimirDebug("Inicio Test.BancoDao.ObtenerTodosPorDescripcionSimilar()");

            BancoDTO[] bancos = dao.ObtenerPorDescripcionSimilar(descripcionUtilizada);
            Assert.IsNotNull(bancos, "Se obtuvo un objeto nulo");
            Assert.IsNotEmpty(bancos, "No se pudo obtener un conjunto de bancos que compartan la misma descripcion");
            ImprimirDebug("Bancos obtenidos : ", bancos);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            Assert.AreEqual(bancos.Length, dao.Eliminar(bancos), "No se pudo eliminar todos los bancos de prueba");
            Assert.IsNull(dao.ObtenerPorDescripcionSimilar(descripcionUtilizada), "Existen bancos con la descripcion utilizada : " +  descripcionUtilizada);

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            Assert.AreEqual(bancos.Length, dao.Agregar(ref bancos), "No se pudieron agregar los bancos eliminados");
            if (bancos.Length > 1)
            {
                id = bancos[0].Id;
            }

            ImprimirDebug("Fin Test.BancoDao.ObtenerTodosPorDescripcionSimilar()");
        }//ObtenerTodosPorDescripcionSimilar

        #endregion

        #region IActivo

        /// <summary>
        /// Valida que se puedan obtener todos los bancos activos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todos los bancos activos de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerActivos()
        {
            ImprimirInfo("Inicio Test.BancoDao.ObtenerActivos()");

            BancoDTO[] bancos = dao.ObtenerActivos();
			ImprimirDebug("Bancos obtenidos : ", bancos);
            Assert.IsNotNull(bancos, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(bancos, "No existen bancos activos o no se pudo obtener un conjunto de bancos activos");
            
            //Validacion de estatus
            ImprimirDebug("Validacion de estatus");
            foreach (BancoDTO b in bancos)
            {
                Assert.IsTrue(b.Activo, "El estatus del banco es inactivo");
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            IList<BancoDTO> bancosPrueba = new List<BancoDTO>();
            foreach (BancoDTO b in bancos)
            {
                if(dao.Desactivar(b))
                {
                    ImprimirDebug("Banco desactivado : ", b);
                    bancosPrueba.Add(b);
                }
            }
            bancos = dao.ObtenerActivos();
            Assert.IsNull(bancos, "El objeto obtenido no es nulo");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (BancoDTO b in bancosPrueba)
            {
                Assert.IsTrue(dao.Activar(b), "No pudo ser activado el banco con id : " + b.Id);
            }

            ImprimirInfo("Fin Test.BancoDao.ObtenerActivos()");
        }//ObtenerActivos

        /// <summary>
        /// Valida que se puedan obtener todos los bancos inactivos de la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se puedan obtener todos los bancos inactivos de la capa de persistencia")]
        [Category("IActivo")]
        public void ObtenerInactivos()
        {
            ImprimirInfo("Inicio Test.BancoDao.ObtenerInactivos()");

            BancoDTO[] bancos = dao.ObtenerInactivos();
            Assert.IsNotNull(bancos, "El objeto obtenido es nulo");
            Assert.IsNotEmpty(bancos, "No existen bancos inactivos o no se pudo obtener un conjunto de bancos inactivos");
            ImprimirDebug("Bancos obtenidos : ", bancos);

            //Validacion de estatus
            ImprimirDebug("Validacion de estatus");
            foreach (BancoDTO b in bancos)
            {
                Assert.IsFalse(b.Activo, "El estatus del banco es activo");
            }

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            IList<BancoDTO> bancosPrueba = new List<BancoDTO>();
            foreach (BancoDTO b in bancos)
            {
                if (dao.Activar(b))
                {
                    ImprimirDebug("Banco activo : ", b);
                    bancosPrueba.Add(b);
                }
            }
            bancos = dao.ObtenerInactivos();
            Assert.IsNull(bancos, "El objeto obtenido no es nulo");

            //Restablezco los datos de prueba utilizados
            ImprimirDebug("Restauracion de datos");
            foreach (BancoDTO b in bancosPrueba)
            {
                Assert.IsTrue(dao.Desactivar(b), "No pudo ser desactivado el banco con id : " + b.Id);
            }

            ImprimirInfo("Fin Test.BancoDao.ObtenerInactivos()");
        }//ObtenerInactivos

        /// <summary>
        /// Valida que se pueda activar un banco en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda activar un banco en la capa de persistencia")]
        [Category("IActivo")]
        public void Activar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Activar()");

            //Obtengo los bancos inactivos de pruebas
            BancoDTO[] bancosInactivos = dao.ObtenerInactivos();
            Assert.IsNotNull(bancosInactivos, "No se pudieron obtener los bancos inactivos registrados en el sistema");
            BancoDTO bancoPrueba = null;
            ImprimirDebug("Obteniendo el banco de prueba...");
            foreach (BancoDTO b in bancosInactivos)
            {
                if(b.Descripcion.Contains(descripcionUtilizada))
                {
                    bancoPrueba = b;
                    break;
                }
            }
            Assert.IsNotNull(bancoPrueba, "No se pudo obtener un banco inactivo para realizar pruebas");

            //Activo el banco
            ImprimirDebug("Banco a ser activado : ", bancoPrueba);
            Assert.IsTrue(dao.Activar(bancoPrueba), "No se puedo activar el banco de prueba");
            ImprimirDebug("Banco activado : ", bancoPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInexistente = new BancoDTO() { Id = -1, Activo = false };
            ImprimirDebug("Banco inexistente a activar", bancoInexistente);
            Assert.Throws<DAOException>(() => dao.Activar(bancoInexistente));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Desactivar(bancoPrueba), "No se pudo restablecer el estado del banco de prueba");

            ImprimirInfo("Fin Test.BancoDao.Activar()");
        }//Activar

        /// <summary>
        /// Valida que se pueda desactivar un banco en la capa de persistencia
        /// </summary>
        [Test(Description = "Valida que se pueda desactivar un banco en la capa de persistencia")]
        [Category("IActivo")]
        public void Desactivar()
        {
            ImprimirInfo("Inicio Test.BancoDao.Desactivar()");

            //Obtengo los bancos activos de pruebas
            BancoDTO[] bancosActivos = dao.ObtenerActivos();
            Assert.IsNotNull(bancosActivos, "No se pudieron obtener los bancos activos registrados en el sistema");
            BancoDTO bancoPrueba = null;
            ImprimirDebug("Obteniendo el banco de prueba...");
            foreach (BancoDTO b in bancosActivos)
            {
                if (b.Descripcion.Contains(descripcionUtilizada))
                {
                    bancoPrueba = b;
                    break;
                }
            }
            Assert.IsNotNull(bancoPrueba, "No se pudo obtener un banco activo para realizar pruebas");

            //Desactivo el banco
            ImprimirDebug("Banco a ser desactivado : ", bancoPrueba);
            Assert.IsTrue(dao.Desactivar(bancoPrueba), "No se puedo desactivar el banco de prueba");
            ImprimirDebug("Banco desactivado : ", bancoPrueba);

            //Validacion negativa
            ImprimirDebug("Validacion negativa");
            BancoDTO bancoInexistente = new BancoDTO() { Id = -1, Activo = true };
            ImprimirDebug("Banco inexistente a desactivar", bancoInexistente);
            Assert.Throws<DAOException>(() => dao.Desactivar(bancoInexistente));

            //Restauracion de datos
            ImprimirDebug("Restauracion de datos");
            Assert.IsTrue(dao.Activar(bancoPrueba), "No se pudo restablecer el estado del banco de prueba");

            ImprimirInfo("Fin Test.BancoDao.Desactivar()");
        }//Desactivar

        #endregion

    }//BancoDao
}//Electrocucaracha.AdminPersonal.DAO.Test